#include "hal_usart.h"
#include "bsp.h"
//static uint16_t TimeSet[5];
//uint16_t const TimeSetBuff[][5] ={
//		{1199, 59, 59, 2378, 2498 }, //1200
//    {539,  59, 59, 1128, 1247 },  //2400
//    {239,  59, 59, 503,  624  },   //4800    
////    {149,  29, 29, 251,  311  },   //9600  //采集
////		{50,  20, 20, 64,  104  },   //9600  //采集
//		{149,  50, 50, 211,  311  },   //9600  //采集
//    {0, 	  0,  0,   0,  0    },         //预留
//};
//tsTypeUsart UARTBuff[ANALOG_USART_NUM_MAX];                //定义串口
//tsTypeUsartPin const UsartPinTable[ANALOG_USART_NUM_MAX] = {
//														//接收端口										//接收引脚									//发送端口									//发送引脚						//定时器
//	{UART_PORT_NOR1_KEY,	USART_RX_NOR1_KEY_GPIO_Port,		USART_RX_NOR1_KEY_Pin,	USART_TX_NOR1_KEY_GPIO_Port,	USART_TX_NOR1_KEY_Pin	,		TMR1,			EINT_LINE_15},  //PB15 
//	{UART_PORT_NOR2_KEY,	USART_RX_NOR2_KEY_GPIO_Port,		USART_RX_NOR2_KEY_Pin,	USART_TX_NOR2_KEY_GPIO_Port,	USART_TX_NOR2_KEY_Pin	,		TMR2,			EINT_LINE_5},		//PB5
//};



///*******************************************************************************
//* @FunctionName   : BitValueChk.
//* @Description    : 判断采集bit值，三次中为1的次数大于等于2则值为1否则为0.
//* @Input          : n 采集记录的位值.
//* @Output         : BitValue.
//* @Return         : BitValue.
//* @Author&Data    : MrShuCai  2019.5.1.
//*******************************************************************************/
//uint8_t BitValueChk(uint8_t n)  //@7 检查有没有1  检查3次有2次是1  就为1
//{
//    uint8_t BitValCx = 0;

//    for(BitValCx = 0; n; n >>= 1)
//    {
//        BitValCx += n & 0x01;
//    }

//    return (BitValCx < 2) ? (0) : (1);

//}

///*******************************************************************************
//* @FunctionName   : UART_Init.
//* @Description    : 模拟串口结构体初始化.
//* @Input          : None.
//* @Output         : None.
//* @Return         : None.
//* @Author&Data    : MrShuCai  2019.4.11.
//*******************************************************************************/
//void OnHalUARTInit(uint32_t BaudRate)
//{
//	  for(uint8_t i = 0; i<ANALOG_USART_NUM_MAX;i++)
//		{
//			UARTBuff[i].CheckType 		= NONE;
//			UARTBuff[i].UartStat 			= COM_NONE_BIT_DEAL;
//			UARTBuff[i].PORT_RX_x 		=	UsartPinTable[i].PORT_RX_x;
//			UARTBuff[i].GPIO_RX_x 		=	UsartPinTable[i].GPIO_RX_x;
//			UARTBuff[i].PORT_TX_x 		=	UsartPinTable[i].PORT_TX_x;
//			UARTBuff[i].GPIO_TX_x 		=	UsartPinTable[i].GPIO_TX_x;
//			UARTBuff[i].TMRx					= UsartPinTable[i].TMRx;
//			UARTBuff[i].ucRecvData		=	0;//每次接收的字节
//			UARTBuff[i].ucAcquCx			=	0;//三次滤波计数
//			UARTBuff[i].ucRecvBitCx		=	0;//接收位计数
//			UARTBuff[i].ucSendBitCx		=	0;//发送位计数
//			UARTBuff[i].ucSendLengCx	=	0; //发送长度计数
//			UARTBuff[i].ucRecvBitBuff	=	0;//采集位保存
//			UARTBuff[i].EINTx					= UsartPinTable[i].EINTx; //中断位号
//		}
//    if(BaudRate == 1200)
//    {
//        memcpy(TimeSet, &TimeSetBuff[0][0], sizeof(TimeSet));
//    }
//    else if(BaudRate == 2400)
//    {
//        memcpy(TimeSet, &TimeSetBuff[1][0], sizeof(TimeSet));
//    }
//    else if(BaudRate == 4800)
//    {
//        memcpy(TimeSet, &TimeSetBuff[2][0], sizeof(TimeSet));
//    }
//    else if(BaudRate == 9600)
//    {
//        memcpy(TimeSet, &TimeSetBuff[3][0], sizeof(TimeSet));
//    }
//    else
//    {

//    }
//}
///*******************************************************************************
//* @FunctionName   : UART_Send_Data.
//* @Description    : 模拟串口发送数据接口.
//* @Input          : None.
//* @Output         : None.
//* @Return         : None.
//* @Author&Data    : MrShuCai  2019.4.11.
//*******************************************************************************/
//void UART_Send_Data(uint8_t * data, uint8_t size,UARTPortDef port)
//{
//	  uint8_t i ;
//		for(i = 0;i<ANALOG_USART_NUM_MAX; i++)
//		{
//			if(port == UsartPinTable[i].UART_PROT_x)
//			{break;}
//		}
//		if(i == ANALOG_USART_NUM_MAX)
//		{return;}
//		
//    UARTBuff[i].Sendlength = size;
//	  UARTBuff[i].UART_Send_buf = data; //指针
//    if(UARTBuff[i].UartStat == COM_NONE_BIT_DEAL)
//		{
//				UARTBuff[i].TxEn = 1;
//				UARTBuff[i].RxEn = 0;
//				UARTBuff[i].UartStat = COM_START_BIT_DEAL;

//				UARTBuff[i].TMRx->AUTORLD = TimeSet[TimeSendStep];

//				UARTBuff[i].TMRx->CEG_B.UEG = 1;//产生更新事件时，预分频器的计数器会清 0

//				TMR_Enable(UARTBuff[i].TMRx);
//		}
//      
//}
//void OnAnalogUsartRx(UARTPortDef port)
//{
//	  uint8_t i ;
//		for(i = 0;i<ANALOG_USART_NUM_MAX; i++)
//		{
//			if(port == UsartPinTable[i].UART_PROT_x)
//			{break;}
//		}
//		if(i == ANALOG_USART_NUM_MAX)
//		{return;}
//	if(UARTBuff[i].UartStat == COM_NONE_BIT_DEAL)
//  {
//			UARTBuff[i].RxEn = 1;
//			UARTBuff[i].ucRecvData = 0;
//			UARTBuff[i].UartStat = COM_START_BIT_DEAL;

//			UARTBuff[i].TMRx->AUTORLD = TimeSet[TimeRecvStartStep1]; 
//			UARTBuff[i].TMRx->CEG_B.UEG = 1;//产生更新事件时，预分频器的计数器会清 0
////			EINT->IMASK &= ~(0x4000);//中断屏蔽寄存器关闭  PB14
////			EINT->EMASK &= ~(0x4000);//中断实践寄存器关闭
//			EINT->IMASK &= ~(UARTBuff[i].EINTx);//中断屏蔽寄存器关闭  
//			EINT->EMASK &= ~(UARTBuff[i].EINTx);//中断实践寄存器关闭
//		
//			TMR_Enable(UARTBuff[i].TMRx);
//   }
//}




//void HAL_ATIM_ANALOG_USARTCallback(UARTPortDef port)
//{
//	  uint8_t i ;
//		for(i = 0;i<ANALOG_USART_NUM_MAX; i++)
//		{
//			if(port == UsartPinTable[i].UART_PROT_x)
//			{break;}
//		}
//		if(i == ANALOG_USART_NUM_MAX)
//		{return;}
//		if(UARTBuff[i].TxEn == 1)         /*数据发送，发送优先，无发送后才进入接收状态*/
//    {
//        switch(UARTBuff[i].UartStat)  /*串口发送位状态判断*/
//        {
//        case COM_START_BIT_DEAL :
//        {
//            HAL_GPIO_WritePin(UARTBuff[i].PORT_TX_x, UARTBuff[i].GPIO_TX_x, GPIO_PIN_RESET);
//            UARTBuff[i].UartStat = COM_DATA_BIT_DEAL;
//            UARTBuff[i].ucSendBitCx = 0;
//        }
//        break;
//			
//				
//        case COM_DATA_BIT_DEAL :
//        {
//            HAL_GPIO_WritePin(UARTBuff[i].PORT_TX_x, UARTBuff[i].GPIO_TX_x, (GPIO_PinState)((UARTBuff[i].UART_Send_buf[UARTBuff[i].ucSendLengCx] >> UARTBuff[i].ucSendBitCx) & 0x01));

//            UARTBuff[i].ucSendBitCx ++;

//            if(UARTBuff[i].ucSendBitCx >= 8)
//            {
//                if(UARTBuff[i].CheckType == NONE)
//                {
//                    UARTBuff[i].UartStat = COM_STOP_BIT_DEAL;
//                }
//                else
//                {
//                    UARTBuff[i].UartStat = COM_CHECK_BIT_DEAL;
//                }
//            }

//        }
//        break;

//        case COM_CHECK_BIT_DEAL :
//        {

//        }
//        break;

//        case COM_STOP_BIT_DEAL :
//        {
//            HAL_GPIO_WritePin(UARTBuff[i].PORT_TX_x, UARTBuff[i].GPIO_TX_x, GPIO_PIN_SET);

//            UARTBuff[i].ucSendBitCx = 0;

//            if(UARTBuff[i].ucSendLengCx < UARTBuff[i].Sendlength - 1)
//            {
//                UARTBuff[i].UartStat = COM_START_BIT_DEAL;
//                UARTBuff[i].ucSendLengCx ++;
//            }
//            else
//            {
//                UARTBuff[i].ucSendLengCx = 0;
//                UARTBuff[i].UartStat = COM_NONE_BIT_DEAL;
//                UARTBuff[i].TxEn = 0;
//                UARTBuff[i].RxEn = 1;

//								TMR_Disable(UARTBuff[i].TMRx);
////								EINT->IMASK |= 0x4000;//中断屏蔽寄存器打开  PB14
////								EINT->EMASK |= 0x4000;//中断实践寄存器打开
//								EINT->IMASK |= UARTBuff[i].EINTx	;//中断屏蔽寄存器打开  
//								EINT->EMASK |= UARTBuff[i].EINTx	;//中断实践寄存器打开
//							
//								UARTBuff[i].TMRx->CNT = 0;
//								HAL_UART_TxCpltCallback(port);//清除标志
//            }
//        }
//        break;

//        default:
//            break;

//        }
//    }
//		if(UARTBuff[i].RxEn == 1)
//    {
//        switch(UARTBuff[i].UartStat)
//        {
//                    case COM_START_BIT_DEAL :
//                    {
//                            UARTBuff[i].ucRecvBitBuff = (UARTBuff[i].ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(UARTBuff[i].PORT_RX_x, UARTBuff[i].GPIO_RX_x) & 0x01);

//                            if(++ UARTBuff[i].ucAcquCx >= 3)
//                            {
//                                    if(BitValueChk(UARTBuff[i].ucRecvBitBuff) == 0)                        
//                                    {
//                                            UARTBuff[i].UartStat = COM_DATA_BIT_DEAL;
//                                            UARTBuff[i].TMRx->AUTORLD = TimeSet[UARTBuff[i].ucAcquCx];
//                                    }
//                                    else
//                                    {
//                                            UARTBuff[i].UartStat = COM_STOP_BIT_DEAL;
//                                    }
//                                    
//                                    UARTBuff[i].ucRecvBitBuff = 0;
//                                    UARTBuff[i].ucAcquCx = 0;
//                            }
//                            else
//                            {
//                                    UARTBuff[i].TMRx->AUTORLD = TimeSet[UARTBuff[i].ucAcquCx];
//                            }


//                    }
//                    break;

//                    case COM_DATA_BIT_DEAL :                         //数据位
//                    {

//                            UARTBuff[i].ucRecvBitBuff = (UARTBuff[i].ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(UARTBuff[i].PORT_RX_x, UARTBuff[i].GPIO_RX_x) & 0x01);

//                            if(++ UARTBuff[i].ucAcquCx >= 3)
//                            {
//                                    UARTBuff[i].ucRecvData |= (BitValueChk(UARTBuff[i].ucRecvBitBuff) & 0x01) << UARTBuff[i].ucRecvBitCx;

//                                    if(UARTBuff[i].ucRecvBitCx >= 7)
//                                    {
//                                            UARTBuff[i].ucRecvBitCx = 0;

//                                            if(UARTBuff[i].CheckType == NONE)
//                                            {
//                                                    UARTBuff[i].UartStat = COM_STOP_BIT_DEAL;
//                                            }
//                                            else
//                                            {
//                                                    UARTBuff[i].UartStat = COM_CHECK_BIT_DEAL;
//                                            }
//                                    }
//                                    else
//                                    {
//                                            UARTBuff[i].ucRecvBitCx ++;
//                                    }

////                                    TIM6->ARR = TimeSet[ucAcquCx];
//																		UARTBuff[i].TMRx->AUTORLD = TimeSet[UARTBuff[i].ucAcquCx]; 
//                                    UARTBuff[i].ucAcquCx = 0;
//                                    UARTBuff[i].ucRecvBitBuff = 0;
//                            }
//                            else
//                            {
//                                    UARTBuff[i].TMRx->AUTORLD = TimeSet[UARTBuff[i].ucAcquCx];
//                            }
//                    }
//                    break;

//                    case COM_CHECK_BIT_DEAL :                         //校验位
//                    {

//                    }
//                    break;

//                    case COM_STOP_BIT_DEAL :                         //停止位
//                    {

//														UARTBuff[i].ucRecvBitBuff = (UARTBuff[i].ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(UARTBuff[i].PORT_RX_x, UARTBuff[i].GPIO_RX_x) & 0x01);

//                            if( ++ UARTBuff[i].ucAcquCx >= 3)
//                            { 
////                                    if(BitValueChk(ucRecvBitBuff) == 1)    
////                                    {
////                                            if(gsUARTBuff.Recvlength < gsUARTBuff.UartMaxLength)
////                                            {
////                                                    gsUARTBuff.UART_Recv_buf[gsUARTBuff.Recvlength] = ucRecvData;
////                                                    gsUARTBuff.Recvlength ++;
////                                            }
//																						   UARTRxTimeOutTab[port].buff[UARTRxTimeOutTab[port].len++] = (uint8_t)UARTBuff[i].ucRecvData;
//																							 if (UARTRxTimeOutTab[port].len >= UARTRxTimeOutTab[port].maxLen) 
//																							 {
//																										OnUartRxTimeOut(port);
//																							 }
//																							 else
//																							 {
//																										UARTRxTimeOutTab[port].timeOut = 5; // 5ms后认为接收超时
//																							 }
//                                            UARTBuff[i].UartStat = COM_NONE_BIT_DEAL;
//                                            TMR_Disable(UARTBuff[i].TMRx);
////																							EINT->IMASK |= 0x4000;//中断屏蔽寄存器打开  PB14
////																							EINT->EMASK |= 0x4000;//中断实践寄存器打开
//																						EINT->IMASK |= UARTBuff[i].EINTx	;//中断屏蔽寄存器打开  
//																						EINT->EMASK |= UARTBuff[i].EINTx	;//中断实践寄存器打开	 
//																							 
//																						UARTBuff[i].TMRx->CNT = 0;
////                                    }
////                                    else
////                                    {
////                                            ucAcquCx = 0;
////                                    }
//                                    
//                                    UARTBuff[i].ucRecvBitBuff = 0;
//                                    UARTBuff[i].ucAcquCx = 0;
//                            }
//                            else
//                            {
//                                    UARTBuff[i].TMRx->AUTORLD = TimeSet[UARTBuff[i].ucAcquCx];
//                            }
//                    }
//                    break;

//                    default:
//                            break;
//                    }
//    }

//    
//}

//void OnHalUSARTTest(void)
//{
////	uint8_t  data[16] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
////	UART_Send_Data(data, 16);
////	static uint8_t i=0;
////	i++;
////	if(i<10)
////	HAL_GPIO_WritePin(USART_TX_NOR2_KEY_GPIO_Port, USART_TX_NOR2_KEY_Pin, GPIO_PIN_SET);
////	else if(i<20)
////	HAL_GPIO_WritePin(USART_TX_NOR2_KEY_GPIO_Port, USART_TX_NOR2_KEY_Pin, GPIO_PIN_RESET);
////  else
////  i=0;		
//}



typedef struct
{
	DMA_T* DMAx;
	DMA_Channel_T* Channle;
	USART_T* USARTx;
} DMA_Channel_TypeDef;

static DMA_Channel_TypeDef  UARTTxDMAChannleTable[MAX_UART_CNT]=//MAX_UART_CNT
{
			 {DMA1,   DMA1_Channel7,    USART_SCREEN}, 			//代表使用的是显示板
			 {DMA1,   DMA1_Channel4,    USART_CAT1},					//代表使用与标准板  占位用 实际没有DMA
			 {DMA1,   DMA1_Channel4,    USART_RO},					//代表使用与RO系统通讯
			 {DMA2,   DMA2_Channel5,    USART_DEBUG},				//串口打印输出，也是生产工具使用的串口

};		

void HAL_UART_Receive_DMA(UARTPortDef port, uint8_t *tbuff, uint16_t tlen)
{
	UARTRxTimeOutTab[port].buff = tbuff;
	UARTRxTimeOutTab[port].maxLen = tlen;
	UARTRxTimeOutTab[port].len = 0;
	UARTRxTimeOutTab[port].rxEnd = 0;
	UARTRxTimeOutTab[port].timeOut = 0;
	UARTRxTimeOutTab[port].flag = 0;
}

void HAL_UART_Transmit_DMA(UARTPortDef port, uint8_t *tbuff, uint16_t tlen)
{
//串口DMA 
	if((port == UART_PORT_SCREEN) || (port == UART_PORT_CTRL) || (port == UART_PORT_LOG))
	{
			DMA_Disable(UARTTxDMAChannleTable[port].Channle);
	
			USART_DisableDMA(UARTTxDMAChannleTable[port].USARTx, USART_DMA_TX);
	
			UARTTxDMAChannleTable[port].Channle->CHMADDR = (uint32_t)tbuff;
	
			DMA_ConfigDataNumber(UARTTxDMAChannleTable[port].Channle, tlen);
	
			DMA_Enable(UARTTxDMAChannleTable[port].Channle);
	
			USART_EnableDMA(UARTTxDMAChannleTable[port].USARTx, USART_DMA_TX);
	}
//串口中断
  else if(port == UART_PORT_IOT)
	{
//			__disable_irq();//关闭所有中断
    for (uint32_t t=0; t<tlen; t++)
    {
        USART_TxData(UART5, tbuff[t]);

        /* wait for the data to be send  */
        while (USART_ReadStatusFlag(UART5, USART_FLAG_TXBE) == RESET);
    }
//			__enable_irq();//打开所有中断
		HAL_UART_TxCpltCallback(UART_PORT_IOT);
		
	}
////串口模拟发送
//	else
//	{
//		UART_Send_Data(tbuff, tlen,port);
//	}
			
//SPI 的DMA
}

